﻿package net.molchat.android.scrn;


//FIXME Commented out class


import net.molchat.android.cont.Cont;
import net.molchat.android.cont.ContOne;
import net.molchat.android.cont.ContRoom;
import net.molchat.android.core.Man;
import net.molchat.android.core.Setting;
import net.molchat.android.core.Tick;
import net.molchat.android.core.TickEvent;
import net.molchat.android.mess.Message;
import android.content.Context;
import android.graphics.Canvas;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;


/**
 * Screen holder and manager. Mainly sends events to Window objects.
 * 
 * @author Valentyn Markovych
 * 
 */


public final class ScrMan extends SurfaceView implements TickEvent,
		SurfaceHolder.Callback {

//==================================================================== Constants


//======================================================================= Fields

// Threads
private Tick tick; // Main animation thread


// Windows
private Win winNow; // Current window
private Splash scrSplash; // Splash screen

// Stuff
private SurfaceHolder sHolder;
public boolean isAlertMode;


private boolean isShown;


//
//// =================================================================== Константы
//private static final int MAX_WINS = 5; // Максимальное кол-во открытых окон
//
// ====================================================================== Screens
private InRoom inRoom; // Список контактов, находящихся в данный момент в комнате


private One scrOne; // Экран контакта
//public OneText oneText; // Экран для написания сообщения перс. контакту
private Room scrRoom; // Экран комнаты
//private RoomText roomText; // Экран для написания сообщения в комнату
//private Win scrSett; // Экран настроек
//
//// ================================================================== Переменные
//
//
//// Отрисовка
//private final Win[] wins = new Win[MAX_WINS]; // Цепочка открытых окон
//private int winP = 0; // Указатель на текущее окно
//
//// Разное
//private boolean fKeyRepeat; // Флаг текущего повторения клавиши
//
//// --------------------------------------------------------------------- Команды
//// Indices must be uniform:
//public static final int COM_MESS = 0;
//public static final int COM_MYINFO = 1;
//public static final int COM_LIST = 2;
//public static final int COM_SEL = 3;
//public static final int COM_WHO = 4;
//public static final int COM_CAN = 5;
//public static final int COM_SHOT = 6;
//public static final int COM_CONNECT = 7;
//public static final int COM_SETTINGS = 8;
//public static final int COM_SEND = 9;
//public static final int COM_MENU = 10;
//public static final int COM_EXIT = 11; // Should ALWAYS has last index
//
//public static final int COM_TOT = COM_EXIT + 1;
//
//public ComPic[] coms = new ComPic[COM_TOT];
//
//{
//	coms[COM_MESS] = new ComPic(null, "Написать", Command.SCREEN, 1);
//	coms[COM_MYINFO] = new ComPic(null, "Моя анкета", Command.SCREEN, 2);
//	coms[COM_LIST] = new ComPic(null, "Контакты", Command.SCREEN, 4);
//	coms[COM_SEL] = new ComPic(null, "Выбрать", Command.OK, 5);
//	coms[COM_WHO] = new ComPic(null, "Кто здесь?", Command.ITEM, 6);
//	coms[COM_CAN] = new ComPic(null, "Отмена", Command.BACK, 7);
//	coms[COM_SHOT] = new ComPic(null, "Снять", Command.OK, 1);
//	//	coms[COM_HISTORY] = new ComPic(null, "Получить историю", Command.ITEM, 8);
//	coms[COM_CONNECT] = new ComPic(null, "Соединиться", Command.ITEM, 9);
//	coms[COM_SETTINGS] = new ComPic(null, "Настройки", Command.SCREEN, 12);
//	coms[COM_SEND] = new ComPic(null, "Отправить", Command.SCREEN, 13);
//	coms[COM_EXIT] = new ComPic(null, "Выход", Command.EXIT, 15);
//}
//
//private final boolean[] comNow = new boolean[COM_TOT]; // Массив команд текущего экрана
//
//private int keyDivider = Setting.keyDivider;
//
//
// =============================================================== Инициализация


public ScrMan(Context context) {

	super(context);
	sHolder = getHolder();
	sHolder.addCallback(this);
	setFocusable(true); // make sure we get key events
	//	setFocusableInTouchMode(true); // make sure we get touch events

	// TODO move this to the constructor
	//Man.picAni = new PicAni();


	Log.v("ScrMan", "ScrMan created.");
}


//======================================================================= chStat
/**
 * Status changed message received.
 * 
 * @param statText
 *          New status text
 * @return If graphic window should be redrawed.
 */
public boolean chStat(String statText) {

	//	Log.v("ScrMan.chStat", "winNow: " + winNow.getClass().getName());
	if (winNow.chStat(statText)) {
		this.showWin(null);
	}

	return false;
}


//// ============================================================ Обработка команд
//public void commandAction(Command command) {
//
//
//	if (command == coms[COM_MESS]) {
//		sendMess(); // Отправить сообщение
//	} else if (command == coms[COM_MENU]) {
//		showMenu(); // Menu
//	} else if (command == coms[COM_WHO]) {
//		outRoomWho(); // Кто здесь?
//	} else if (command == coms[COM_LIST]) {
//		showContList(); // Отобразить список контактов пользователя
//	} else if (command == coms[COM_SETTINGS]) {
//		showSetting(); // Отобразить экран настроек
//	} else if (command == coms[COM_CONNECT]) {
//		Man.ioMan.connect(); // Соединиться
//	} else if (command == coms[COM_CAN]) {
//		showMain(); // Cancel pressed, show main window
//	} else if (command == coms[COM_EXIT]) { // Выход
//		exit(Mess.LOCAL);
//	} else {
//		winNow.command(command);
//	}
//}
//
//
////===================================================================== showMenu
//private void showMenu() {
//
//	ScrMenu winMenu = new ScrMenu();
//	setCom(winNow.getComs(), winMenu);
//	String title;
//	int contType = Man.contMan.getSelType();
//	switch (contType) {
//		case Cont.ONE:
//			title = "Меню контакта";
//			break;
//		case Cont.ROOM:
//			title = "Меню комнаты";
//			break;
//		default:
//			title = "Меню";
//	}
//	winMenu.setTitle(title);
//	showWin(winMenu);
//}
//
//
//// ================================================== Освободить ресурсы и выйти
//public void exit(int fromHere) {
//
//	disp.setCurrent(this);
//
//	if (fromHere <= Mess.LOCAL) {
//		Man.main.exit(Mess.FROM_DOWN);
//	}
//
//	if (tick != null) {
//		tick.exit();
//	}
//
//	Draw.exit();
//
//	scrOne = null; // Экран контакта
//	scrRoom = null; // Экран комнаты
//	scrSplash = null; // Экран загрузки
//
//	disp = null; // Дисплей
//}


//====================================================================== fOnline
/**
 * Reseived network status message.
 * 
 * @param online
 */
public void fOnline(boolean online) {

	// FIXME commented out block

	//	boolean fOnline = !online;
	//
	//	// Экран загрузки
	//	scrSplash.coms[COM_CONNECT] = fOnline;
	//
	//	// Экран комнаты
	//	if (scrRoom != null) {
	//		scrRoom.coms[COM_CONNECT] = fOnline;
	//	}
	//
	//	// Экран персонального контакта
	//	if (scrOne != null) {
	//		scrOne.coms[COM_CONNECT] = fOnline;
	//	}
	//
	//	winNow.fOnline(online);
	//	this.showWin(winNow);

}


//// ============================= Получено событие состояния "в сети / не в сети"
//public void fOnline(boolean online) {
//
//	boolean fOnline = !online;
//
//	// Экран загрузки
//	scrSplash.coms[COM_CONNECT] = fOnline;
//
//	// Экран комнаты
//	if (scrRoom != null) {
//		scrRoom.coms[COM_CONNECT] = fOnline;
//	}
//
//	// Экран персонального контакта
//	if (scrOne != null) {
//		scrOne.coms[COM_CONNECT] = fOnline;
//	}
//
//	winNow.fOnline(online);
//	this.showWin(winNow);
//
//}
//
//
//// ============================================= Извещение о пришедшем сообщении
//public String getTitStr(int contType, int contNum, Message message, int nickLen) {
//
//	String titText = "...";
//
//	switch (contType) {
//
//		case Cont.ONE:
//			MessOne messOne = (MessOne) message;
//
//			titText = Man.contMan.getFrom(contNum, nickLen)
//					+ ": "
//					+ messOne.text.substring(0,
//							Math.min(Win.NUM_TEXT_LETT, messOne.text.length()));
//			break;
//
//		case Cont.ROOM:
//			MessRoom messRoom = (MessRoom) message;
//			titText = messRoom.fromCache.substring(0,
//					Math.min(nickLen, messRoom.fromCache.length()))
//					+ ": "
//					+ messRoom.text.substring(0,
//							Math.min(Win.NUM_TEXT_LETT, messRoom.text.length()));
//			break;
//
//		default:
//			Log.v("ScrMan.getTitStr", "Неизвестный тип контакта: " + contType);
//	}
//
//	return titText;
//}
//
//
////============================================== Declare touch screen processing
//public boolean hasPointerEvents() {
//
//	return true;
//}
//
//
//public boolean hasPointerMotionEvents() {
//
//	return true;
//}
//
//
//// ============================================== Оповещение об отображении окна
//public void hideNotify() {
//
//	if (tick != null) {
//		tick.pauseTick();
//	}
//}
//
//

//======================================================================= inFind
/**
 * We got search result list.
 * 
 * @param contType
 *          Contact type
 * @param conts
 *          Contacts list
 */
public void inFind(int contType, Cont[] conts) {

	// FIXME commented out block

	switch (contType) {

		case Cont.ONE:
			//			showWin(new AddOne(((ContOne[]) conts)));
			break;

		case Cont.ROOM:
			//			showWin(new AddRoom(((ContRoom[]) conts)));
			break;

		default:
			Log.v("ScrMan.inFind", "Неизвестный тип контакта: " + contType);
	}


}


//// ============================================================ Initialization
//public void init(Display display) {
//
//	Log.v("ScrMan.init", "=====");
//
//	// toMain = event;
//	Draw.setGr(this.getGraphics());
//
//	Man.picAni = new PicAni();
//
//	disp = display;
//	disp.setCurrent(this);
//	Thread.yield(); // Для устранения глюка с зависанием и для ускорения отображения окна
//	this.setFullScreenMode(true);
//
//	Draw.initFont();
//
//	setCommandListener(this);
//
//	Draw.dispW = this.getWidth();
//	Draw.dispH = this.getHeight();
//
//	tick = new Tick(Setting.tickSpeed, this);
//	tick.resumeTick();
//
//	this.fAlert = false;
//}
//
//
//// ====================================================== Подтверждение доставки
//public void inRes(int contType, int contNum) {
//
//	switch (contType) {
//
//		case Cont.ONE:
//			if (this.isShown() && Man.contMan.isSel(contType, contNum)
//					&& (winNow == scrOne)) {
//				winNow.prepare(null);
//				this.flushGraphics();
//			}
//			break;
//
//		case Cont.ROOM:
//			if (this.isShown() && Man.contMan.isSel(contType, contNum)
//					&& (winNow == scrRoom)) {
//				winNow.prepare(null);
//				this.flushGraphics();
//			}
//			break;
//
//		default:
//			Log.v("ScrMan.inText", "Неизвестный тип контакта: " + contType);
//	}
//
//}
//
//

//==================================================================== inRoomWho
/**
 * Got contacts list for requested room
 * 
 * @param roomNum
 *          Room number
 * @param ones
 *          Contact list of type One
 */
public void inRoomWho(int roomNum, ContOne[] ones) {

	// FIXME commented out block

	if ((winNow == inRoom) && (Man.contMan.isSel(Cont.ROOM, roomNum))) {
		//		inRoom.inRoomWho(roomNum, ones);
	}

}


//// ======================================== Получен список находящихся в комнате
//public void inRoomWho(int roomNum, ContOne[] ones) {
//
//	if ((winNow == inRoom) && (Man.contMan.isSel(Cont.ROOM, roomNum))) {
//		inRoom.inRoomWho(roomNum, ones);
//	}
//
//}
//
//

//======================================================================= inText
public void inText(int contType, int contNum, Message message) {

	if (winNow.inText(contType, contNum, message)) {
		this.showWin(null);
	}
}


//// ============================================= Извещение о пришедшем сообщении
//public void inText(int contType, int contNum, Message message) {
//
//	if (winNow.inText(contType, contNum, message)) {
//		this.flushGraphics();
//	}
//}


/**
 * Hardware keyboard events processing.
 */
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {

	Log.v("ScrMan.keyPressed", "Pressed key with code " + keyCode);

	Log.v("ScrMan.keyPressed", "Really isInTouchMode = " + isInTouchMode());

	if (winNow.keyDown(keyCode, event)) {
		this.drawBuffer();
	}

	Log.v("ScrMan.keyPressed", "Key down event processed for code " + keyCode);

	return true;
}


//// =============================================== Обработчик событий клавиатуры
//public void keyPressed(int keyCode) {
//
//	int action = getGameAction(keyCode);
//	//	Log.v("ScrMan.keyPressed", "Нажата клавиша " + keyCode);
//
//	if (winNow.keyPressed(action)) {
//		this.flushGraphics();
//	}
//
//	//	Log.v("ScrMan.keyPressed", "Нажатие отработано " + keyCode);
//}
//
//
//// =============================================== Обработчик событий клавиатуры
//public void keyRepeated(int keyCode) {
//
//	fKeyRepeat = true;
//}
//
//
////============================================ Отправить запрос списка контактов
//public void outRoomWho() {
//
//	// TODO Если кол-во контактов с прошлого запроса не изменялось, можно не отправлять новый запрос, а отобразить тот же список
//	try {
//
//		int contNum = Man.contMan.getSelNum();
//		Cont cont = Man.contMan.getSelCont();
//		if (cont instanceof ContRoom) {
//			ContRoom room = (ContRoom) cont;
//			inRoom = new InRoom(room.titText);
//			showWin(inRoom);
//
//			Man.ioMan.outRoomWho(contNum);
//		}
//
//	} catch (Exception e) {
//		Log.e("One.outRoomWho", "Ошибка отправки запроса");
//	}
//
//}


//// ================================================== Отобразить предыдущее окно
//public void retWin(Win winOld) {
//
//	if (winOld == null) {
//		showMain();
//	} else {
//		// Задаем окно
//		if (--winP <= 0) {
//			winP = MAX_WINS - 1;
//		}
//
//		showWin(winOld);
//	}
//}


//======================= Определить тип сообщения и вызвать обработчик отправки
public void sendMess() {

	// FIXME commented out method

	Cont cont;
	int contType;
	int contNum;

	try {

		cont = Man.contMan.getSelCont();
		contType = Man.contMan.getSelType();
		contNum = Man.contMan.getSelNum();

		switch (contType) {

		//			case Cont.ONE:
		//				if (oneText == null) {
		//					oneText = new OneText();
		//				}
		//
		//				oneText.setup((ContOne) cont, contNum);
		//
		//				showWin(oneText);
		//				break;
		//
		//			case Cont.ROOM:
		//				MessRoom messSel = (MessRoom) ((ContRoom) cont).getSel();
		//				MessRoom messOut;
		//
		//				if (messSel != null) {
		//					messOut = messSel.copyIn2Out();
		//				} else {
		//					messOut = new MessRoom();
		//					messOut.tarType = MessRoom.TAR_ALL;
		//					messOut.tarCache = "Всем: ";
		//				}
		//
		//				showRoomText(messOut, contNum, (ContRoom) cont);
		//
		//				break;

			default:
				Log.v("ScrMan.sendMess", "Неизвестный тип контакта " + contType);
		}

	} catch (Exception e) {
		Log.e("ScrMan.sendMess", "Не могу отобразить экран", e);
	}


}


//// ============================================= Задать набор необходимых команд
//public void setCom(boolean[] comNeed, Displayable screen) {
//
//	if (comNeed != null) {
//		for (int q = 0; q < COM_TOT; ++q) {
//			if (screen == this) { // Optimized algorithm
//				if (comNeed[q] && (!comNow[q])) { // Команда нужна
//					screen.addCommand(coms[q]);
//					comNow[q] = true;
//				} else if ((!comNeed[q]) && comNow[q]) { // Команда не нужна
//					removeCommand(coms[q]);
//					comNow[q] = false;
//				}
//			} else if (comNeed[q]) { // Normal algorithm
//				screen.addCommand(coms[q]);
//			}
//		}
//	}
//
//}
//
//
////=================================== Отобразить сообщение сервера или программы
//public void showAlert(String title, String text, int sec, boolean fModal) {
//
//	if (text.indexOf("Неправильный") >= 0) { // TODO Make a normal check without strings comparison
//		winNow = new NewName();
//	} else {
//		winNow = null;
//	}
//
//	Al alert = new Al(title, text, null, Al.INFO, sec);
//	alert.show();
//
//	fAlert = fModal;
//
//}
//
//
//// ================================================= Отобразить список контактов
//public void showContList() {
//
//	if (Man.contList == null) {
//		Man.contList = new ContList();
//	}
//
//	Man.contList.setTitle("Список контактов:");
//	showWin(Man.contList);
//}


//==================================================================== getCurWin
/**
 * Detect and return current window. Newer returns null.
 */
public Win getCurWin() {

	Win resultWin = null;

	Cont cont;
	int contType;
	int contNum;

	try {

		cont = Man.contMan.getSelCont();
		contType = Man.contMan.getSelType();
		contNum = Man.contMan.getSelNum();

		switch (contType) {

			case Cont.ONE:
				Log.v("ScrMan.getCurWin", "Включаю экран контакта " + contNum);
				if (scrOne == null) {
					scrOne = new One();
				}

				scrOne.setCont((ContOne) cont, contNum);
				resultWin = scrOne;
				break;

			case Cont.ROOM:
				//				Log.v("ScrMan.showMain", "Включаю экран комнаты " + contNum);
				if (scrRoom == null) {
					scrRoom = new Room();
					// scrSplash = null;
				}
				scrRoom.setCont((ContRoom) cont, contNum);
				resultWin = scrRoom;
				break;

			case Cont.UNK:
				resultWin = scrSplash;
				break;
		}


	} catch (Exception e) {
		Log.e("ScrMan.getCurWin", "Не могу отобразить экран", e);
	}

	return resultWin;

}


//// ========================================================== Новый пользователь
//public void showNew() {
//
//	showWin(new NewName());
//}
//
//
//// ===================================================== При появлении на экране
//protected void showNotify() {
//
//	Draw.dispW = this.getWidth();
//	Draw.dispH = this.getHeight();
//
//	if (winNow != null) {
//		winNow.prepare(null);
//	}
//	this.flushGraphics();
//
//	if (tick != null) {
//		tick.resumeTick();
//	}
//}


/**
 * Shows previous contact (or previous contact that has unread messages).
 * 
 */
public void showPrevCont() {

	Man.contMan.selPrev();
	showWin(getCurWin());
}


/**
 * Shows the next contact (or next contact that has unread messages).
 * 
 */
public void showNextCont() {

	Man.contMan.selNext();
	showWin(getCurWin());
}


//// ============================== Отобразить экран отправки текстового сообщения
//public void showRoomText(MessRoom messOut, int roomNum, ContRoom room) {
//
//	if (roomText == null) {
//		roomText = new RoomText();
//	}
//
//	roomText.setup(messOut, roomNum, room);
//
//	showWin(roomText);
//
//}
//
//
//// =================================================== Отобразить экран настроек
//public void showSetting() {
//
//	try {
//		scrSett = new ScrSett();
//	} catch (Exception e) {
//		Log.e("ScrMan.showSplash", "Не могу отобразить экран настроек", e);
//		scrSett = winNow;
//	}
//	showWin(scrSett);
//}
//
//

//=================================================================== showSplash
/**
 * Create and show splash window.
 * 
 */
public void createSplash() {

	scrSplash = new Splash();
	if (isShown) {
		showWin(scrSplash);
	}
}


//// =================================================== Отобразить экран загрузки
//public void showSplash() {
//
//	try {
//		scrSplash = new Splash();
//	} catch (Exception e) {
//		Log.e("ScrMan.showSplash", "Не могу отобразить экран загрузки");
//	}
//	showWin(scrSplash);
//}
//
//

/**
 * Draws the current graphical buffer to the real screen.
 * 
 * @param sHolder
 */
private void drawBuffer() {

	Canvas canvas = null;

	try {

		canvas = sHolder.lockCanvas();
		canvas.drawBitmap(Draw.bmp, 0, 0, null);

	} catch (Exception e) {
		Log.v("ScrMan.drawBuffer", "Error while drawing buffer", e);
	} finally {
		if (canvas != null) {
			sHolder.unlockCanvasAndPost(canvas);
		}
	}


}


//============================================================= Отобразить окно
public void showWin(Win nextWin) {

	if (!isAlertMode) {

		if (nextWin == null) { // Show current window
			nextWin = getCurWin();
		}

		if (nextWin != null) {

			this.winNow = nextWin;

			// Отображаем окно
			nextWin.prepare(null); // Окно готовит себя к отображению

			//		nextWin.prepare(this.winNow); // Окно готовит себя к отображению

			//		wins[winP] = nextWin;
			//		this.winNow = nextWin;

			if (nextWin.isGraphic()) { // Окно отрисовывает программа
				this.drawBuffer();
				//			setCom(nextWin.getComs(), this);
				//			this.flushGraphics();
				//			disp.setCurrent(this);
			}
			//		else { // Окно отрисовывает Java-машина телефона
			//			disp.setCurrent((Displayable) nextWin);
			//			Thread.yield(); // Для устранения глюка с зависанием и для ускорения отображения окна
			//			this.setFullScreenMode(true);
			//		}
		}

	}

	Log.v("ScrMan.showWin", "winNow: " + winNow.getClass().getName()
			+ ", nextWin: " + nextWin.getClass().getName());
}


//// ============================================================= Отобразить окно
//public void showWin(Win winNow) {
//
//	if (!fAlert) {
//		// Задаем окно
//		if (++winP >= MAX_WINS) {
//			winP = 0;
//		}
//
//		// Отображаем окно
//		winNow.prepare(this.winNow); // Окно готовит себя к отображению
//
//		wins[winP] = winNow;
//		this.winNow = winNow;
//
//		if (winNow.isGraphic()) { // Окно отрисовывает программа
//			setCom(winNow.getComs(), this);
//			this.flushGraphics();
//			disp.setCurrent(this);
//		} else { // Окно отрисовывает Java-машина телефона
//			disp.setCurrent((Displayable) winNow);
//			Thread.yield(); // Для устранения глюка с зависанием и для ускорения отображения окна
//			this.setFullScreenMode(true);
//		}
//	}
//}
//
//
//// ============================================= Изменился размер поля отрисовки
//public void sizeChanged(int newW, int newH) {
//
//	synchronized (Man.main) {
//		Draw.sizeChanged(newW, newH);
//	}
//
//	if ((winNow != null) && (this.isShown()) && (winNow.isGraphic())) {
//		winNow.prepare(null);
//	}
//}
//
//

//=================================================================== splashNext
/**
 * Show next splash screen text.
 * 
 * @param text
 *          Text to show
 * @param percent
 *          Current process percentage
 */
public void splashNext(String text, int percent) {

	scrSplash.next(text, percent);
	if (isShown) {
		showWin(scrSplash);
	}
}


// ====================================================== Событие среды анимации
@Override
public boolean tick() {

	//	Log.v("ScrMan.tick", "...tick...");

	if (winNow == null) {
		return false;
	}


	// FIXME commented out method

	boolean fFlush = false;

	//
	//
	//		if (--this.keyDivider <= 0) {
	//			this.keyDivider = Setting.keyDivider;
	//			if (fKeyRepeat) {
	//				int state = this.getKeyStates();
	//
	//				if (state != 0) {
	//					fFlush |= winNow.keyState(state);
	//				} else {
	//					fKeyRepeat = false;
	//				}
	//			}
	//		}

	fFlush |= winNow.tick();

	if (fFlush) {
		this.drawBuffer();
	}

	return false;
}


//====================================================================== vibrate
public void vibrate(int duration) {

	// Log.v("ScrMan.vibra", "Вибрируем " + duration + " мс");
	if (Setting.fVibra) {
		//		disp.vibrate(duration);
	}
}


@Override
public void surfaceChanged(SurfaceHolder sHolder, int format, int width,
		int height) {

	Log.v("ScrMan.surfaceChanged", "surface changed. New size is " + width
			+ " x " + height + ". Starting filling");

	this.sHolder = sHolder;

	// Copied from 'init' method
	Draw.sizeChanged(width, height);

	Log.v("ScrMan.surfaceChanged", "isShown = true");
	this.isShown = true;
	this.showWin(null);
}


@Override
public void surfaceCreated(SurfaceHolder sHolder) {


	Log.v("ScrMan.surfaceCreated", "surface created.");
	this.sHolder = sHolder;

	// Copied from 'init' method

	tick = new Tick(Setting.tickSpeed, this);
	//	tick = new Tick(1000, this);
	tick.resumeTick();

	this.isAlertMode = false;
}


@Override
public void surfaceDestroyed(SurfaceHolder arg0) {

	this.isShown = false;
	tick.exit();
	this.tick = null;
}


//==================================================================== waitShown
/**
 * Waits for millisec time to be shown. Returns true if ok, false otherwise.
 * 
 * @return
 */
public boolean waitShown(int millisec) {

	if (isShown) {
		return true;
	}

	this.bringToFront();

	while (!isShown && millisec > 0) {
		millisec -= 500;
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
		}
	}

	return isShown;
}


//@Override
//public boolean onTouch(View v, MotionEvent event) {
//
//	Log.d("ScrMan.onTouch", "onTouch event received: " + event);
//
//	return true;
//}


@Override
public boolean onTouchEvent(MotionEvent event) {

	// Differentiate event type to pointerPressed, pointerDragged or pointerReleased
	switch (event.getActionMasked()) {

		case MotionEvent.ACTION_DOWN:
			winNow.pointerPressed((int) event.getX(), (int) event.getY());
			break;

		case MotionEvent.ACTION_MOVE:
			winNow.pointerDragged((int) event.getX(), (int) event.getY());
			break;

		case MotionEvent.ACTION_CANCEL:
			Log.d("ScrMan.onTouch", "action is ACTION_CANCEL");
			break;

		case MotionEvent.ACTION_UP:
			Log.d("ScrMan.onTouch", "action is ACTION_UP");
			winNow.pointerReleased((int) event.getX(), (int) event.getY());
			break;

		default:
			break;
	}


	return true;
}


//@Override
//public void onClick(View arg0) {
//
//	Log.d("ScrMan.onTouch", "onClick event received");
//
//}


}
